package com.ruoyi.system.service.impl;

import java.util.List;
import com.ruoyi.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import com.ruoyi.common.utils.StringUtils;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.system.domain.SubTask;
import com.ruoyi.system.mapper.MainTaskMapper;
import com.ruoyi.system.domain.MainTask;
import com.ruoyi.system.service.IMainTaskService;

/**
 * 主任务Service业务层处理
 * 
 * @author zhaoyu
 * @date 2025-06-18
 */
@Service
public class MainTaskServiceImpl implements IMainTaskService 
{
    @Autowired
    private MainTaskMapper mainTaskMapper;

    /**
     * 查询主任务
     * 
     * @param taskId 主任务主键
     * @return 主任务
     */
    @Override
    public MainTask selectMainTaskByTaskId(Long taskId)
    {
        return mainTaskMapper.selectMainTaskByTaskId(taskId);
    }

    /**
     * 查询主任务列表
     * 
     * @param mainTask 主任务
     * @return 主任务
     */
    @Override
    public List<MainTask> selectMainTaskList(MainTask mainTask)
    {
        return mainTaskMapper.selectMainTaskList(mainTask);
    }

    /**
     * 新增主任务
     * 
     * @param mainTask 主任务
     * @return 结果
     */
    @Transactional
    @Override
    public int insertMainTask(MainTask mainTask)
    {
        mainTask.setCreateTime(DateUtils.getNowDate());
        int rows = mainTaskMapper.insertMainTask(mainTask);
        insertSubTask(mainTask);
        return rows;
    }

    /**
     * 修改主任务
     * 
     * @param mainTask 主任务
     * @return 结果
     */
    @Transactional
    @Override
    public int updateMainTask(MainTask mainTask)
    {
        mainTask.setUpdateTime(DateUtils.getNowDate());
        mainTaskMapper.deleteSubTaskByMainTaskId(mainTask.getTaskId());
        insertSubTask(mainTask);
        int result = mainTaskMapper.updateMainTask(mainTask);

        if (result > 0) {
            updateMainTaskStatusBySubTasks(mainTask.getTaskId());
        }
        
        return result;
    }

    /**
     * 批量删除主任务
     * 
     * @param taskIds 需要删除的主任务主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteMainTaskByTaskIds(Long[] taskIds)
    {
        mainTaskMapper.deleteSubTaskBySubTaskIds(taskIds);
        return mainTaskMapper.deleteMainTaskByTaskIds(taskIds);
    }

    /**
     * 删除主任务信息
     * 
     * @param taskId 主任务主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteMainTaskByTaskId(Long taskId)
    {
        mainTaskMapper.deleteSubTaskByMainTaskId(taskId);
        return mainTaskMapper.deleteMainTaskByTaskId(taskId);
    }

    /**
     * 新增子任务信息
     * 
     * @param mainTask 主任务对象
     */
    public void insertSubTask(MainTask mainTask)
    {
        List<SubTask> subTaskList = mainTask.getSubTaskList();
        Long taskId = mainTask.getTaskId();
        if (StringUtils.isNotNull(subTaskList))
        {
            List<SubTask> list = new ArrayList<SubTask>();
            for (SubTask subTask : subTaskList)
            {
                subTask.setMainTaskId(taskId);
                list.add(subTask);
            }
            if (list.size() > 0)
            {
                mainTaskMapper.batchSubTask(list);
            }
        }
    }

    /**
     * 检查主任务是否可以编辑
     * 
     * @param taskId 主任务ID
     * @return 是否可编辑
     */
    @Override
    public boolean checkTaskEditable(Long taskId)
    {
        List<SubTask> subTasks = mainTaskMapper.selectSubTaskByMainTaskId(taskId);
        if (subTasks == null || subTasks.isEmpty()) {
            return true;
        }
        // 检查是否有已接收的子任务（状态 > 0）
        for (SubTask subTask : subTasks) {
            if (subTask.getStatus() != null && subTask.getStatus() > 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * 检查主任务是否可以删除
     * 
     * @param taskId 主任务ID
     * @return 是否可删除
     */
    @Override
    public boolean checkTaskDeletable(Long taskId)
    {
        List<SubTask> subTasks = mainTaskMapper.selectSubTaskByMainTaskId(taskId);
        if (subTasks == null || subTasks.isEmpty()) {
            return true;
        }
        // 检查是否有已接收的子任务（状态 > 0）
        for (SubTask subTask : subTasks) {
            if (subTask.getStatus() != null && subTask.getStatus() > 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * 获取主任务的子任务状态统计
     * 
     * @param taskId 主任务ID
     * @return 子任务状态统计
     */
    @Override
    public java.util.Map<String, Object> getSubTaskStatus(Long taskId)
    {
        List<SubTask> subTasks = mainTaskMapper.selectSubTaskByMainTaskId(taskId);
        java.util.Map<String, Object> result = new java.util.HashMap<>();
        
        int total = subTasks != null ? subTasks.size() : 0;
        int notStarted = 0; // 0
        int inProgress = 0; // 1
        int completed = 0;  // 2
        int exception = 0;  // 3
        
        if (subTasks != null) {
            for (SubTask subTask : subTasks) {
                Integer status = subTask.getStatus();
                if (status == null || status == 0) {
                    notStarted++;
                } else if (status == 1) {
                    inProgress++;
                } else if (status == 2) {
                    completed++;
                } else if (status == 3) {
                    exception++;
                }
            }
        }
        
        result.put("total", total);
        result.put("notStarted", notStarted);
        result.put("inProgress", inProgress);
        result.put("completed", completed);
        result.put("exception", exception);
        
        return result;
    }

    /**
     * 根据子任务状态自动更新主任务状态
     * 
     * @param mainTaskId 主任务ID
     * @return 结果
     */
    @Override
    public int updateMainTaskStatusBySubTasks(Long mainTaskId)
    {
        MainTask mainTask = mainTaskMapper.selectMainTaskByTaskId(mainTaskId);
        if (mainTask == null) {
            return 0;
        }
        
        List<SubTask> subTasks = mainTaskMapper.selectSubTaskByMainTaskId(mainTaskId);

        if (subTasks == null || subTasks.isEmpty()) {
            return 0;
        }
        
        int newStatus = calculateMainTaskStatus(subTasks, mainTask.getStatus());

        if (newStatus == mainTask.getStatus()) {
            return 0;
        }
        
        // 更新主任务状态
        MainTask updateTask = new MainTask();
        updateTask.setTaskId(mainTaskId);
        updateTask.setStatus(newStatus);
        updateTask.setUpdateTime(DateUtils.getNowDate());
        
        return mainTaskMapper.updateMainTask(updateTask);
    }
    
    /**
     * 根据子任务状态计算主任务状态
     * 
     * @param subTasks 子任务列表
     * @param currentStatus 当前主任务状态
     * @return 新的主任务状态
     */
    private int calculateMainTaskStatus(List<SubTask> subTasks, Integer currentStatus)
    {
        boolean hasInProgress = false;
        boolean hasNotStarted = false;
        boolean allCompleted = true;
        boolean hasException = false;
        
        for (SubTask subTask : subTasks) {
            Integer status = subTask.getStatus();
            if (status == null || status == 0) {
                hasNotStarted = true;
                allCompleted = false;
            } else if (status == 1) {
                hasInProgress = true;
                allCompleted = false;
            } else if (status == 2) {
                // 已完成，不影响allCompleted的判断
            } else if (status == 3) {
                hasException = true;
                allCompleted = false;
            }
        }

        // 1. 如果所有子任务都已完成，主任务状态为已完成
        if (allCompleted) {
            return 2;
        }
        
        // 2. 如果有异常子任务，主任务状态为异常
        if (hasException) {
            return 3;
        }
        
        // 3. 如果有进行中的子任务，主任务状态为进行中
        if (hasInProgress) {
            return 1;
        }
        
        // 4. 如果主任务当前是待接收状态且任何子任务状态变化，主任务状态变为进行中
        if (currentStatus != null && currentStatus == 0 && !hasNotStarted) {
            return 1;
        }
        
        // 5. 如果主任务已处于进行中状态，且子任务都是未开始状态，保持进行中状态
        if (currentStatus != null && currentStatus == 1) {
            return 1;
        }
        
        // 6. 其他情况保持当前状态或设为待接收
        return currentStatus != null ? currentStatus : 0;
    }

    /**
     * 接收主任务，将主任务状态从待接收(0)变为进行中(1)
     * 
     * @param taskId 主任务ID
     * @return 结果
     */
    @Override
    public int receiveMainTask(Long taskId)
    {
        MainTask mainTask = mainTaskMapper.selectMainTaskByTaskId(taskId);
        if (mainTask == null) {
            return 0;
        }

        if (mainTask.getStatus() == null || mainTask.getStatus() != 0) {
            return 0;
        }

        MainTask updateTask = new MainTask();
        updateTask.setTaskId(taskId);
        updateTask.setStatus(1);
        updateTask.setUpdateTime(DateUtils.getNowDate());
        
        return mainTaskMapper.updateMainTask(updateTask);
    }
}
